home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / buffer_head.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  9KB  |  298 lines
  1. /*
  2.  * include/linux/buffer_head.h
  3.  *
  4.  * Everything to do with buffer_heads.
  5.  */
  6.  
  7. #ifndef _LINUX_BUFFER_HEAD_H
  8. #define _LINUX_BUFFER_HEAD_H
  9.  
  10. #include <linux/types.h>
  11. #include <linux/fs.h>
  12. #include <linux/linkage.h>
  13. #include <linux/pagemap.h>
  14. #include <linux/wait.h>
  15. #include <asm/atomic.h>
  16.  
  17. enum bh_state_bits {
  18.     BH_Uptodate,    /* Contains valid data */
  19.     BH_Dirty,    /* Is dirty */
  20.     BH_Lock,    /* Is locked */
  21.     BH_Req,        /* Has been submitted for I/O */
  22.  
  23.     BH_Mapped,    /* Has a disk mapping */
  24.     BH_New,        /* Disk mapping was newly created by get_block */
  25.     BH_Async_Read,    /* Is under end_buffer_async_read I/O */
  26.     BH_Async_Write,    /* Is under end_buffer_async_write I/O */
  27.     BH_Delay,    /* Buffer is not yet allocated on disk */
  28.     BH_Boundary,    /* Block is followed by a discontiguity */
  29.     BH_Write_EIO,    /* I/O error on write */
  30.     BH_Ordered,    /* ordered write */
  31.     BH_Eopnotsupp,    /* operation not supported (barrier) */
  32.  
  33.     BH_PrivateStart,/* not a state bit, but the first bit available
  34.              * for private allocation by other entities
  35.              */
  36. };
  37.  
  38. #define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
  39.  
  40. #ifdef __KERNEL__
  41.  
  42. struct page;
  43. struct buffer_head;
  44. struct address_space;
  45. typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
  46.  
  47. /*
  48.  * Keep related fields in common cachelines.  The most commonly accessed
  49.  * field (b_state) goes at the start so the compiler does not generate
  50.  * indexed addressing for it.
  51.  */
  52. struct buffer_head {
  53.     /* First cache line: */
  54.     unsigned long b_state;        /* buffer state bitmap (see above) */
  55.     struct buffer_head *b_this_page;/* circular list of page's buffers */
  56.     struct page *b_page;        /* the page this bh is mapped to */
  57.     atomic_t b_count;        /* users using this block */
  58.     u32 b_size;            /* block size */
  59.  
  60.     sector_t b_blocknr;        /* block number */
  61.     char *b_data;            /* pointer to data block */
  62.  
  63.     struct block_device *b_bdev;
  64.     bh_end_io_t *b_end_io;        /* I/O completion */
  65.      void *b_private;        /* reserved for b_end_io */
  66.     struct list_head b_assoc_buffers; /* associated with another mapping */
  67. };
  68.  
  69. /*
  70.  * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
  71.  * and buffer_foo() functions.
  72.  */
  73. #define BUFFER_FNS(bit, name)                        \
  74. static inline void set_buffer_##name(struct buffer_head *bh)        \
  75. {                                    \
  76.     set_bit(BH_##bit, &(bh)->b_state);                \
  77. }                                    \
  78. static inline void clear_buffer_##name(struct buffer_head *bh)        \
  79. {                                    \
  80.     clear_bit(BH_##bit, &(bh)->b_state);                \
  81. }                                    \
  82. static inline int buffer_##name(const struct buffer_head *bh)        \
  83. {                                    \
  84.     return test_bit(BH_##bit, &(bh)->b_state);            \
  85. }
  86.  
  87. /*
  88.  * test_set_buffer_foo() and test_clear_buffer_foo()
  89.  */
  90. #define TAS_BUFFER_FNS(bit, name)                    \
  91. static inline int test_set_buffer_##name(struct buffer_head *bh)    \
  92. {                                    \
  93.     return test_and_set_bit(BH_##bit, &(bh)->b_state);        \
  94. }                                    \
  95. static inline int test_clear_buffer_##name(struct buffer_head *bh)    \
  96. {                                    \
  97.     return test_and_clear_bit(BH_##bit, &(bh)->b_state);        \
  98. }                                    \
  99.  
  100. /*
  101.  * Emit the buffer bitops functions.   Note that there are also functions
  102.  * of the form "mark_buffer_foo()".  These are higher-level functions which
  103.  * do something in addition to setting a b_state bit.
  104.  */
  105. BUFFER_FNS(Uptodate, uptodate)
  106. BUFFER_FNS(Dirty, dirty)
  107. TAS_BUFFER_FNS(Dirty, dirty)
  108. BUFFER_FNS(Lock, locked)
  109. TAS_BUFFER_FNS(Lock, locked)
  110. BUFFER_FNS(Req, req)
  111. TAS_BUFFER_FNS(Req, req)
  112. BUFFER_FNS(Mapped, mapped)
  113. BUFFER_FNS(New, new)
  114. BUFFER_FNS(Async_Read, async_read)
  115. BUFFER_FNS(Async_Write, async_write)
  116. BUFFER_FNS(Delay, delay)
  117. BUFFER_FNS(Boundary, boundary)
  118. BUFFER_FNS(Write_EIO, write_io_error)
  119. BUFFER_FNS(Ordered, ordered)
  120. BUFFER_FNS(Eopnotsupp, eopnotsupp)
  121.  
  122. #define bh_offset(bh)        ((unsigned long)(bh)->b_data & ~PAGE_MASK)
  123. #define touch_buffer(bh)    mark_page_accessed(bh->b_page)
  124.  
  125. /* If we *know* page->private refers to buffer_heads */
  126. #define page_buffers(page)                    \
  127.     ({                            \
  128.         BUG_ON(!PagePrivate(page));        \
  129.         ((struct buffer_head *)(page)->private);    \
  130.     })
  131. #define page_has_buffers(page)    PagePrivate(page)
  132.  
  133. /*
  134.  * Declarations
  135.  */
  136.  
  137. void FASTCALL(mark_buffer_dirty(struct buffer_head *bh));
  138. void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
  139. void set_bh_page(struct buffer_head *bh,
  140.         struct page *page, unsigned long offset);
  141. int try_to_free_buffers(struct page *);
  142. struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
  143.         int retry);
  144. void create_empty_buffers(struct page *, unsigned long,
  145.             unsigned long b_state);
  146. void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
  147. void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
  148. void end_buffer_async_write(struct buffer_head *bh, int uptodate);
  149.  
  150. /* Things to do with buffers at mapping->private_list */
  151. void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
  152. int inode_has_buffers(struct inode *);
  153. void invalidate_inode_buffers(struct inode *);
  154. int remove_inode_buffers(struct inode *inode);
  155. int sync_mapping_buffers(struct address_space *mapping);
  156. void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
  157.  
  158. void mark_buffer_async_write(struct buffer_head *bh);
  159. void invalidate_bdev(struct block_device *, int);
  160. int sync_blockdev(struct block_device *bdev);
  161. void __wait_on_buffer(struct buffer_head *);
  162. wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
  163. int fsync_bdev(struct block_device *);
  164. struct super_block *freeze_bdev(struct block_device *);
  165. void thaw_bdev(struct block_device *, struct super_block *);
  166. int fsync_super(struct super_block *);
  167. int fsync_no_super(struct block_device *);
  168. struct buffer_head *__find_get_block(struct block_device *, sector_t, int);
  169. struct buffer_head * __getblk(struct block_device *, sector_t, int);
  170. void __brelse(struct buffer_head *);
  171. void __bforget(struct buffer_head *);
  172. void __breadahead(struct block_device *, sector_t block, int size);
  173. struct buffer_head *__bread(struct block_device *, sector_t block, int size);
  174. struct buffer_head *alloc_buffer_head(int gfp_flags);
  175. void free_buffer_head(struct buffer_head * bh);
  176. void FASTCALL(unlock_buffer(struct buffer_head *bh));
  177. void FASTCALL(__lock_buffer(struct buffer_head *bh));
  178. void ll_rw_block(int, int, struct buffer_head * bh[]);
  179. int sync_dirty_buffer(struct buffer_head *bh);
  180. int submit_bh(int, struct buffer_head *);
  181. void write_boundary_block(struct block_device *bdev,
  182.             sector_t bblock, unsigned blocksize);
  183.  
  184. extern int buffer_heads_over_limit;
  185.  
  186. /*
  187.  * Generic address_space_operations implementations for buffer_head-backed
  188.  * address_spaces.
  189.  */
  190. int try_to_release_page(struct page * page, int gfp_mask);
  191. int block_invalidatepage(struct page *page, unsigned long offset);
  192. int block_write_full_page(struct page *page, get_block_t *get_block,
  193.                 struct writeback_control *wbc);
  194. int block_read_full_page(struct page*, get_block_t*);
  195. int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
  196. int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
  197.                 loff_t *);
  198. int generic_cont_expand(struct inode *inode, loff_t size) ;
  199. int block_commit_write(struct page *page, unsigned from, unsigned to);
  200. int block_sync_page(struct page *);
  201. sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
  202. int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
  203. int block_truncate_page(struct address_space *, loff_t, get_block_t *);
  204. int file_fsync(struct file *, struct dentry *, int);
  205. int nobh_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
  206. int nobh_commit_write(struct file *, struct page *, unsigned, unsigned);
  207. int nobh_truncate_page(struct address_space *, loff_t);
  208.  
  209. /*
  210.  * inline definitions
  211.  */
  212.  
  213. static inline void attach_page_buffers(struct page *page,
  214.         struct buffer_head *head)
  215. {
  216.     page_cache_get(page);
  217.     SetPagePrivate(page);
  218.     page->private = (unsigned long)head;
  219. }
  220.  
  221. static inline void get_bh(struct buffer_head *bh)
  222. {
  223.         atomic_inc(&bh->b_count);
  224. }
  225.  
  226. static inline void put_bh(struct buffer_head *bh)
  227. {
  228.         smp_mb__before_atomic_dec();
  229.         atomic_dec(&bh->b_count);
  230. }
  231.  
  232. static inline void brelse(struct buffer_head *bh)
  233. {
  234.     if (bh)
  235.         __brelse(bh);
  236. }
  237.  
  238. static inline void bforget(struct buffer_head *bh)
  239. {
  240.     if (bh)
  241.         __bforget(bh);
  242. }
  243.  
  244. static inline struct buffer_head *
  245. sb_bread(struct super_block *sb, sector_t block)
  246. {
  247.     return __bread(sb->s_bdev, block, sb->s_blocksize);
  248. }
  249.  
  250. static inline void
  251. sb_breadahead(struct super_block *sb, sector_t block)
  252. {
  253.     __breadahead(sb->s_bdev, block, sb->s_blocksize);
  254. }
  255.  
  256. static inline struct buffer_head *
  257. sb_getblk(struct super_block *sb, sector_t block)
  258. {
  259.     return __getblk(sb->s_bdev, block, sb->s_blocksize);
  260. }
  261.  
  262. static inline struct buffer_head *
  263. sb_find_get_block(struct super_block *sb, sector_t block)
  264. {
  265.     return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
  266. }
  267.  
  268. static inline void
  269. map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
  270. {
  271.     set_buffer_mapped(bh);
  272.     bh->b_bdev = sb->s_bdev;
  273.     bh->b_blocknr = block;
  274. }
  275.  
  276. /*
  277.  * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
  278.  * __wait_on_buffer() just to trip a debug check.  Because debug code in inline
  279.  * functions is bloaty.
  280.  */
  281. static inline void wait_on_buffer(struct buffer_head *bh)
  282. {
  283.     might_sleep();
  284.     if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
  285.         __wait_on_buffer(bh);
  286. }
  287.  
  288. #endif /* __KERNEL__ */
  289.  
  290. static inline void lock_buffer(struct buffer_head *bh)
  291. {
  292.     might_sleep();
  293.     if (test_set_buffer_locked(bh))
  294.         __lock_buffer(bh);
  295. }
  296.  
  297. #endif /* _LINUX_BUFFER_HEAD_H */
  298.